# -*- coding: utf-8 -*-
#
# Copyright (c) 2025 Huawei Technologies Co., Ltd.
# openUBMC is licensed under Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#         http://license.coscl.org.cn/MulanPSL2
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.

"""
模板函数发射器
"""

from typing import cast
from ...ir import IRNode
from ...ir.expressions import IRCall, IRAttribute, IRName
from ...ir.expressions.literals import IRList, IRDict, IRSet, IRTuple
from ...ir.declarations.import_node import IRImportNode
from ..core.emitter import BaseEmitter, EmitResult
from ..core.context import CodeGenContext
from ...symbol_meta import Symbol, SymbolKind
from ...type_system import get_cpp_type
from ...symbol_registry import get_global_registry
from ..core.generator import get_global_generator
from ..configs.operators import get_operator_precedence


class TemplateEmitter(BaseEmitter):
    """模板函数发射器"""

    # 临时变量计数器（类级别）
    _temp_var_counter = 0

    def __init__(self):
        # 通过符号表统一查找所有带模板的函数
        pass

    @staticmethod  # type: ignore
    def _count_self_occurrences(template: str) -> int:
        """统计模板中 {self} 出现的次数"""
        return template.count("{self}")

    @staticmethod  # type: ignore
    def _is_temporary_container(ir_node: IRNode) -> bool:
        """判断IR节点是否是临时容器字面值"""
        return isinstance(ir_node, (IRList, IRDict, IRSet, IRTuple))

    @classmethod  # type: ignore
    def _get_next_temp_var_name(cls) -> str:
        """生成唯一的临时变量名"""
        cls._temp_var_counter += 1
        return f"__mcpy_temp_{cls._temp_var_counter}"

    def can_emit(self, node: IRNode, context: CodeGenContext) -> bool:
        """检查是否为带模板或回调的函数调用"""
        if not isinstance(node, IRCall):
            return False

        func_name = node.get_func_name()
        if not func_name:
            return False

        # 检查函数是否有模板定义或回调
        args_types = self._get_args_types(node, context)
        symbol = self._lookup_symbol(node, func_name, context, args_types)
        has_template = bool(symbol and self._has_template(symbol))
        has_callback = bool(symbol and self._has_callback(symbol, args_types))

        return has_template or has_callback

    def emit(self, node: IRCall, context: CodeGenContext) -> EmitResult | None:
        """生成模板函数调用代码"""
        # 使用统一的模板系统处理函数调用
        func_name = node.get_func_name()
        if func_name:
            # 先检查是否有回调处理器
            callback_result = self._try_callback(node, func_name, context)
            if callback_result:
                return callback_result

            # 尝试使用模板，如果没有模板返回 None 让其他 emitter 处理
            return self._emit_with_template(node, func_name, context)

        return None  # 未知函数名，让其他 emitter 处理

    def _try_callback(
        self, node: IRCall, func_name: str, context: CodeGenContext
    ) -> EmitResult | None:
        """尝试使用回调处理器生成代码

        Args:
            node: 函数调用节点
            func_name: 函数名
            context: 代码生成上下文

        Returns:
            EmitResult 或 None（如果没有回调或回调不处理）
        """
        args_types = self._get_args_types(node, context)
        symbol = self._lookup_symbol(node, func_name, context, args_types)

        if not symbol:
            return None

        # 获取最佳匹配的签名
        signature = symbol.find_matching_signature(args_types)
        if not signature:
            return None

        # 检查签名是否有回调
        callback_path = getattr(signature, "callback_path", None)
        if not callback_path:
            return None

        # 加载并调用回调
        try:
            callback_class = self._load_callback(callback_path)
            if callback_class and hasattr(callback_class, "emit"):
                # 实例化回调类并调用 emit 方法
                callback_instance = callback_class()
                result = callback_instance.emit(node, context)
                if result:
                    # 如果result是字符串，包装成EmitResult
                    if isinstance(result, str):
                        return EmitResult(code=result, precedence=2)
                    return result
        except Exception as e:
            # 回调失败，记录错误但继续使用模板
            import sys

            print(f"警告: 回调 {callback_path} 执行失败: {e}", file=sys.stderr)
            import traceback

            traceback.print_exc(file=sys.stderr)

        return None

    @staticmethod  # type: ignore
    def _load_callback(callback_path: str):
        """加载回调类

        Args:
            callback_path: 回调路径，格式为 "module.path:ClassName"

        Returns:
            回调类或None
        """
        try:
            module_path, class_name = callback_path.rsplit(":", 1)
            parts = module_path.split(".")

            # 动态导入模块
            module = __import__(module_path)
            for part in parts[1:]:
                module = getattr(module, part)

            # 获取类
            callback_class = getattr(module, class_name)
            return callback_class
        except Exception as e:
            import sys

            print(f"警告: 无法加载回调 {callback_path}: {e}", file=sys.stderr)
            return None

    def _lookup_symbol(
        self, node: IRCall, func_name: str, context: CodeGenContext, args_types=None
    ):
        """统一的符号查找逻辑，支持函数重载匹配"""
        if not context.current_node:
            return None

        # 1. 尝试使用缓存的符号
        cached_symbol = self._try_cached_symbol(node, args_types)
        if cached_symbol:
            return cached_symbol

        # 2. 对于成员调用，尝试模块函数查找
        if node.is_member_call():
            module_func = self._lookup_module_function(node, args_types)
            if module_func:
                return module_func

        # 3. 构造查找参数并执行标准查找
        lookup_args_types, owner_type = self._prepare_lookup_params(node, args_types)
        if node.is_member_call() and owner_type is None:
            return None  # 对象类型未知，无法查找方法

        result = node.lookup_symbol(
            func_name,
            func_args=lookup_args_types,
            owner_type=owner_type,
        )

        # 4. 处理类型与函数同名的情况（如 bool）
        if result and self._is_class_symbol_conflict(result, node):
            return self._lookup_global_function(func_name, lookup_args_types) or result

        return result

    def _try_cached_symbol(self, node: IRCall, args_types) -> Symbol | None:
        """尝试使用节点缓存的符号"""
        symbol: Symbol | None = node.func.get_extension_param("symbol")
        if symbol and symbol.find_matching_signature(args_types):
            return symbol
        return None

    def _lookup_module_function(self, node: IRCall, args_types) -> Symbol | None:
        """查找模块函数（如 copy.deepcopy）"""
        if not isinstance(node.func, IRAttribute):
            return None
        if not isinstance(node.func.value, IRName):
            return None

        module_name = node.func.value.id
        method_name = node.func.attr

        # 查找模块符号
        module_symbol = node.lookup_symbol(
            module_name, symbol_kinds=[SymbolKind.MODULE]
        )
        if not module_symbol or not module_symbol.ir_node:
            return None

        # 从模块的符号表中查找函数
        import_node = cast(IRImportNode, module_symbol.ir_node)
        resolved_module = import_node.resolved_modules.get(module_name)
        if not resolved_module:
            return None

        return resolved_module.lookup_symbol(method_name, func_args=args_types)

    def _prepare_lookup_params(self, node: IRCall, args_types):
        """准备符号查找参数

        对于方法调用，第一个参数是对象类型（owner_type），
        其余参数是实际的方法参数
        """
        if not node.is_member_call() or not args_types:
            return args_types, None

        owner_type = args_types[0]  # 对象类型（TypeInfo）
        lookup_args_types = args_types[1:]  # 实际的方法参数
        return lookup_args_types, owner_type

    def _is_class_symbol_conflict(self, symbol: Symbol, node: IRCall) -> bool:
        """检查是否是类型与函数同名的冲突（如 bool）"""
        return not node.is_member_call() and symbol.kind == SymbolKind.CLASS

    def _lookup_global_function(self, func_name: str, args_types) -> Symbol | None:
        """在全局符号注册表中查找函数"""
        registry = get_global_registry()
        return registry.lookup_global_function(func_name, args_types)

    def _get_param_cpp_types(
        self, node: IRCall, signature, context: CodeGenContext
    ) -> list:
        """获取函数参数的 C++ 类型列表

        优先从符号的 TypeInfo 获取（已经进行了模板参数替换），
        而不是从 Signature.param_types（原始字符串）。

        Args:
            node: 调用节点
            signature: 函数签名
            context: 代码生成上下文

        Returns:
            参数 C++ 类型列表
        """
        # 尝试从缓存的符号获取TypeInfo（已经进行了模板参数替换）
        cached_symbol = None
        if isinstance(node.func, IRAttribute):
            cached_symbol = node.func.get_extension_param("symbol")

        if cached_symbol and cached_symbol.type_info and cached_symbol.type_info.args:
            # 从 TypeInfo 获取参数类型（已经替换了模板参数）
            from ...type_system import get_cpp_type

            cpp_types = []
            # 对于方法调用，跳过第一个参数（self）
            start_index = 1 if isinstance(node.func, IRAttribute) else 0

            for param_type_info in cached_symbol.type_info.args[start_index:]:
                try:
                    cpp_type = get_cpp_type(param_type_info, node)
                    cpp_types.append(cpp_type)
                except:
                    cpp_types.append(None)

            return cpp_types

        # 回退：从 Signature.param_types 获取（可能包含未替换的模板参数）
        if not signature or not hasattr(signature, "param_types"):
            return []

        from ...type_system import get_cpp_type, parse_type_with_context

        cpp_types = []
        for param_type_str in signature.param_types:
            # 跳过 self 参数（方法调用）
            if param_type_str == "self" or (
                isinstance(node.func, IRAttribute) and len(cpp_types) == 0
            ):
                if isinstance(node.func, IRAttribute):
                    # 第一个参数是 self，跳过
                    continue

            # 将类型字符串转换为 C++ 类型
            try:
                # 使用感知符号系统的解析函数，能够正确识别 TypeVar
                type_info = parse_type_with_context(param_type_str, node=node)
                cpp_type = get_cpp_type(type_info, node)
                cpp_types.append(cpp_type)
            except:
                cpp_types.append(None)

        return cpp_types

    def _has_template(self, symbol: Symbol) -> bool:
        """检查符号是否有可用的模板

        只有当符号有匹配的签名且该签名有模板时才返回True
        """
        # 如果符号没有签名，直接返回False
        if not symbol.signatures:
            return False

        # 检查是否有任何签名有模板
        for signature in symbol.signatures:
            if signature.emit_template:
                return True

        return False

    def _has_callback(self, symbol: Symbol, args_types=None) -> bool:
        """检查符号是否有可用的回调

        Args:
            symbol: 符号
            args_types: 参数类型列表

        Returns:
            如果有匹配的签名且该签名有回调则返回True
        """
        if not symbol or not symbol.signatures:
            return False

        # 获取最佳匹配的签名
        signature = symbol.find_matching_signature(args_types)
        if not signature:
            return False

        # 检查签名是否有回调
        callback_path = getattr(signature, "callback_path", None)
        return bool(callback_path)

    def _get_args_types(self, node: IRCall, context: CodeGenContext):
        """获取函数调用参数的类型信息"""
        args_types = []

        # 检查是否为模块函数调用（如 copy.deepcopy）
        is_module_function_call = False
        if node.is_member_call() and isinstance(node.func, IRAttribute):
            if isinstance(node.func.value, IRName):
                # 检查是否是模块符号
                module_name = node.func.value.id
                module_symbol = node.lookup_symbol(
                    module_name, symbol_kinds=[SymbolKind.MODULE]
                )
                # 只有当找到模块符号且不是类符号时，才认为是模块函数调用
                if module_symbol and module_symbol.kind == SymbolKind.MODULE:
                    is_module_function_call = True

        if node.is_member_call() and not is_module_function_call:
            # 对象方法调用：需要将对象类型作为第一个参数
            object_type = node.get_object_type()
            if object_type:
                args_types.append(object_type)
            else:
                args_types.append(None)

        # 添加实际的函数参数类型
        for arg in node.args or []:
            type_info = arg.get_extension_param("inferred_type")
            if type_info:
                args_types.append(type_info)
            else:
                # 如果没有类型信息，返回None让签名匹配使用默认逻辑
                args_types.append(None)

        # 添加关键字参数类型
        for _, arg in node.keywords or []:
            type_info = arg.get_extension_param("inferred_type")
            if type_info:
                args_types.append(type_info)
            else:
                args_types.append(None)

        # 添加 **kwargs 参数类型
        if node.starargs:
            type_info = node.starargs.get_extension_param("inferred_type")
            if type_info:
                args_types.append(type_info)
            else:
                args_types.append(None)

        return args_types

    def _emit_with_template(
        self, node: IRCall, func_name: str, context: CodeGenContext
    ) -> EmitResult | None:
        """使用符号表和模板系统生成函数代码"""

        generator = get_global_generator()

        # 获取参数类型用于重载匹配
        args_types = self._get_args_types(node, context)

        # 查找符号表中的模板函数配置
        symbol = self._lookup_symbol(node, func_name, context, args_types)

        if not symbol:
            return None  # 没有找到符号，返回 None 让其他 emitter 处理

        # 获取最佳匹配的签名
        signature = symbol.find_matching_signature(args_types)

        if not signature or not signature.emit_template:
            return None  # 没有模板，返回 None 让其他 emitter 处理（如静态方法调用）

        # 生成参数代码，考虑参数覆盖
        args = []
        param_overrides = getattr(signature, "param_overrides", {}) or {}

        # 获取参数的期望类型
        param_cpp_types = self._get_param_cpp_types(node, signature, context)

        # 处理位置参数
        for i, arg in enumerate(node.args or []):
            # 获取该参数的期望类型
            expected_cpp_type = param_cpp_types[i] if i < len(param_cpp_types) else None

            # 创建带期望类型的上下文
            arg_context = context.create_child_context(
                expected_cpp_type=expected_cpp_type
            )
            arg_code = generator.generate_expression(
                arg, arg_context, parent_precedence=100
            )

            # 检查是否需要参数转换
            # 如果参数有覆盖类型（如 argc: int 但实际需要 int*），自动添加 & 操作符
            arg_code = self._apply_param_override(
                arg_code, i, signature, param_overrides
            )

            args.append(arg_code)

        # 处理关键字参数 - 存储为字典以便按名称替换
        keyword_args = {}
        for key, value in node.keywords:
            if key:
                value_code = generator.generate_expression(
                    value, context, parent_precedence=100
                )
                keyword_args[key] = value_code

        # 使用签名的模板
        template = getattr(signature, "emit_template", "")

        # 对于无参数的泛型构造函数（如 list()），如果节点已经有明确的 cpp_type，
        # 直接使用它生成代码，而不是使用可能已经实例化为默认类型的模板
        # 注意：这个优化只适用于构造函数调用，不适用于成员方法调用（如 a.copy()）或全局函数
        # 判断条件：无参数 + 不是成员调用 + 不是方法签名
        if not node.args and not node.is_member_call() and not signature.is_method:
            cpp_type = node.get_extension_param("cpp_type")
            if cpp_type and "<" in cpp_type:
                # 提取初始化语法（{} 或 ()）
                if template.endswith("{}"):
                    return EmitResult(
                        code=f"{cpp_type}{{}}",
                        precedence=get_operator_precedence("call"),
                    )
                elif template.endswith("()"):
                    return EmitResult(
                        code=f"{cpp_type}()", precedence=get_operator_precedence("call")
                    )

        # 添加必要的包含文件
        includes = getattr(signature, "includes", [])
        for include in includes:
            context.require_include(include)

        # 替换模板中的占位符
        code = template

        # 如果是方法调用，替换 {self} 为对象代码（除非是类方法）
        is_method_call = isinstance(node.func, IRAttribute)
        is_classmethod = getattr(signature, "is_classmethod", False)

        if is_method_call and isinstance(node.func, IRAttribute) and not is_classmethod:
            obj_code = generator.generate_expression(node.func.value, context)

            # 兜底机制：检测多个 {self} 展开 + 临时容器字面值的场景
            # 用立即执行lambda包装，避免多次求值导致的悬垂引用
            self_count = self._count_self_occurrences(code)
            is_temp_container = self._is_temporary_container(node.func.value)

            if self_count >= 2 and is_temp_container:
                # 生成唯一的临时变量名
                temp_var = self._get_next_temp_var_name()

                # 替换 {self} 为临时变量名
                template_with_temp = code.replace("{self}", temp_var)

                # 用立即执行lambda包装
                code = f"[&]() {{ auto {temp_var} = {obj_code}; return {template_with_temp}; }}()"
            else:
                # 正常替换
                code = code.replace("{self}", obj_code)
        elif is_classmethod and "{self}" in code:
            # 类方法不应该有 {self} 占位符，但如果有就移除
            # 这是一个配置错误，应该使用其他占位符
            pass

        # 替换泛型类型参数（如 {K}, {V}, {T}）
        if is_method_call and args_types:
            owner_type_info = args_types[0]  # 对象的类型信息
            code = self._replace_type_parameters(code, owner_type_info, context)
        else:
            # 对于全局函数调用，优先尝试从 inferred_type 获取类型参数
            # 这对类型构造函数（如 list()、list([1,2,3])）都有效
            inferred_type = node.get_extension_param("inferred_type")
            if inferred_type and hasattr(inferred_type, "args") and inferred_type.args:
                # 使用推导出的类型参数替换模板中的占位符
                # 这会替换返回类型的模板参数，如 list[T] 中的 {T}
                code = self._replace_type_parameters(code, inferred_type, context)

            # 检查是否有泛型参数绑定（对于普通泛型函数）
            # 这会替换函数签名的模板参数，如 Iterable[T_comparable] 中的 {T_comparable}
            # 需要在 inferred_type 处理之后执行，因为两者可能同时存在
            generic_type_params = node.get_extension_param("generic_type_params")
            if generic_type_params:
                code = self._replace_generic_parameters(
                    code, generic_type_params, context
                )

        # 替换参数占位符
        if "{args}" in code:
            # 处理可变参数
            # 检查是否为宏，如果是宏则对参数进行保护
            is_macro = getattr(signature, "is_macro", False)
            if is_macro:
                from .call_emitter import CallEmitter
                call_emitter = CallEmitter()
                protected_args = [call_emitter._protect_macro_arg(arg) for arg in args]
                code = code.replace("{args}", ", ".join(protected_args))
            else:
                code = code.replace("{args}", ", ".join(args))
        else:
            # 处理具名参数，使用签名中的参数名
            signature_args = getattr(signature, "args", [])
            param_defaults = getattr(signature, "param_defaults", {})
            optional_fragments = getattr(signature, "optional_fragments", {})

            # 对于实例方法调用，签名的第一个参数是 self，需要跳过
            # 对于类方法，签名中没有 self，不需要跳过
            param_offset = (
                1
                if (
                    is_method_call
                    and not is_classmethod
                    and signature_args
                    and signature_args[0] == "self"
                )
                else 0
            )

            # 第一步：记录哪些参数被提供了
            provided_params = set()
            for i, arg in enumerate(args):
                param_index = i + param_offset
                if param_index < len(signature_args):
                    param_name = signature_args[param_index]
                    provided_params.add(param_name)
            for param_name in keyword_args.keys():
                provided_params.add(param_name)

            # 第二步：处理可选参数占位符（{?param}）
            # 这些占位符表示：如果参数未提供则移除，如果提供则替换为 ", {param}"
            import re

            optional_param_pattern = r"\{\?(\w+)\}"

            def replace_optional(match):
                param_name = match.group(1)
                if param_name in provided_params:
                    return f", {{{param_name}}}"
                else:
                    return ""

            code = re.sub(optional_param_pattern, replace_optional, code)

            # 第三步：替换位置参数
            # 检查是否为宏，如果是宏则对参数进行保护
            is_macro = getattr(signature, "is_macro", False)
            
            # 导入宏参数保护函数
            from .call_emitter import CallEmitter
            call_emitter = CallEmitter()
            
            for i, arg in enumerate(args):
                param_index = i + param_offset
                if param_index < len(signature_args):
                    param_name = signature_args[param_index]
                    # 如果是宏，对参数进行保护
                    protected_arg = call_emitter._protect_macro_arg(arg) if is_macro else arg
                    code = code.replace(f"{{{param_name}}}", protected_arg)

            # 第四步：替换关键字参数
            for param_name, param_value in keyword_args.items():
                # 如果是宏，对参数进行保护
                protected_value = call_emitter._protect_macro_arg(param_value) if is_macro else param_value
                code = code.replace(f"{{{param_name}}}", protected_value)

            # 第五步：对于未提供的可选参数，使用默认值替换
            for param_name, default_value in param_defaults.items():
                placeholder = f"{{{param_name}}}"
                if placeholder in code:
                    code = code.replace(placeholder, default_value)

        return EmitResult(code=code, precedence=2)

    def _replace_generic_parameters(
        self, template: str, generic_type_params: dict, context: CodeGenContext
    ) -> str:
        """替换模板中的泛型类型参数（用于全局函数）

        Args:
            template: 模板字符串（如 "mcpy::set<{T}>{}"）
            generic_type_params: 类型参数映射（如 {"T": TypeInfo(name="int")}）
            context: 代码生成上下文

        Returns:
            替换后的模板字符串（如 "mcpy::set<int>{}"）
        """
        from mcpy.type_system import get_cpp_type
        from mcpy.symbol_registry import get_global_registry

        registry = get_global_registry()
        result = template

        for param_name, type_info in generic_type_params.items():
            # 将 TypeInfo 转换为 C++ 类型字符串
            # 需要传递 registry 才能正确查找类型映射
            cpp_type = get_cpp_type(type_info, None, registry)
            if cpp_type:
                # 替换模板中的占位符 {T}, {K}, {V} 等
                placeholder = f"{{{param_name}}}"
                result = result.replace(placeholder, cpp_type)

        return result

    def _replace_type_parameters(
        self, template: str, owner_type_info, context: CodeGenContext
    ) -> str:
        """替换模板中的泛型类型参数（如 {K}, {V}, {T}）

        Args:
            template: 模板字符串
            owner_type_info: 对象的 TypeInfo（包含泛型参数）
            context: 代码生成上下文

        Returns:
            替换后的模板字符串
        """
        if not owner_type_info or not hasattr(owner_type_info, "args"):
            return template

        # 获取全局符号注册表
        registry = get_global_registry()

        # 获取类型的泛型参数
        type_args = owner_type_info.args if hasattr(owner_type_info, "args") else []

        # 从 owner_type_info 中获取模板参数名称列表
        # 例如：dict[K, V] 的 template_params 为 ["K", "V"]
        #       list[T] 的 template_params 为 ["T"]
        type_param_names = []
        if (
            hasattr(owner_type_info, "template_params")
            and owner_type_info.template_params
        ):
            type_param_names = owner_type_info.template_params
        else:
            # 如果 TypeInfo 没有 template_params（通常是实例化的类型如 dict[str, int]）
            # 需要查找模板定义（如 dict）来获取模板参数名称

            # 查找模板类型的定义
            template_symbol = registry._template_types.get(owner_type_info.name)
            if template_symbol and template_symbol.type_info:
                type_param_names = template_symbol.type_info.template_params or []

        # 替换每个类型参数
        for i, param_name in enumerate(type_param_names):
            if i < len(type_args):
                type_arg = type_args[i]
                # 将 TypeInfo 转换为 C++ 类型字符串
                cpp_type = get_cpp_type(type_arg, None, registry)
                # 替换模板中的占位符（同时支持 {T} 和 T 两种格式）
                if cpp_type:
                    template = template.replace(f"{{{param_name}}}", cpp_type)
                    # 对于裸露的模板参数（如 vector<T> 中的 T），也进行替换
                    # 使用正则确保只替换模板参数，不替换其他包含该字母的词
                    import re

                    # 匹配 <T> 或 <T, 或 , T> 中的 T
                    template = re.sub(
                        r"<\s*" + re.escape(param_name) + r"\s*([,>])",
                        f"<{cpp_type}\\1",
                        template,
                    )

        return template

    def _emit_fallback(
        self, node: IRCall, func_name: str, context: CodeGenContext
    ) -> EmitResult:
        """回退处理：简单的函数调用"""
        generator = get_global_generator()

        # 生成参数代码
        args = []
        for arg in node.args or []:
            arg_code = generator.generate_expression(
                arg, context, parent_precedence=100
            )
            args.append(arg_code)

        # 简单的函数调用
        code = f"{func_name}({', '.join(args)})"

        return EmitResult(code=code, precedence=2)

    def _apply_param_override(
        self, arg_code: str, arg_index: int, signature, param_overrides: dict
    ) -> str:
        """应用参数覆盖，自动添加类型转换操作符

        Args:
            arg_code: 参数代码
            arg_index: 参数索引
            signature: 函数签名
            param_overrides: 参数覆盖字典 {参数名: 覆盖类型}

        Returns:
            可能经过转换的参数代码
        """
        if not param_overrides:
            return arg_code

        # 获取参数名（从签名的 args 列表）
        if not hasattr(signature, "args") or arg_index >= len(signature.args):
            # 从 param_types 推导参数名（如果没有 args 列表）
            # 这种情况下无法准确匹配，返回原始代码
            return arg_code

        param_name = signature.args[arg_index]

        # 检查该参数是否有覆盖类型
        if param_name not in param_overrides:
            return arg_code

        override_type = param_overrides[param_name]

        # 如果覆盖类型是 Pointer[T]，需要取地址
        if isinstance(override_type, str) and override_type.startswith("Pointer["):
            return f"&{arg_code}"

        return arg_code

    def get_priority(self) -> int:
        """模板函数发射器的优先级"""
        return 100  # 高优先级，但低于 AssignmentEmitter(10) 和 StatementEmitter
